home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / ip / manage / snmp / cmu-snmp1.0 / apps / snmpnetstat / inet.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-09-20  |  13.7 KB  |  525 lines
  1. /***********************************************************
  2.     Copyright 1989 by Carnegie Mellon University
  3.  
  4.                       All Rights Reserved
  5.  
  6. Permission to use, copy, modify, and distribute this software and its 
  7. documentation for any purpose and without fee is hereby granted, 
  8. provided that the above copyright notice appear in all copies and that
  9. both that copyright notice and this permission notice appear in 
  10. supporting documentation, and that the name of CMU not be
  11. used in advertising or publicity pertaining to distribution of the
  12. software without specific, written prior permission.  
  13.  
  14. CMU DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  15. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  16. CMU BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  17. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  18. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  19. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  20. SOFTWARE.
  21. ******************************************************************/
  22. /*
  23.  * Copyright (c) 1983,1988 Regents of the University of California.
  24.  * All rights reserved.
  25.  *
  26.  * Redistribution and use in source and binary forms are permitted
  27.  * provided that this notice is preserved and that due credit is given
  28.  * to the University of California at Berkeley. The name of the University
  29.  * may not be used to endorse or promote products derived from this
  30.  * software without specific prior written permission. This software
  31.  * is provided ``as is'' without express or implied warranty.
  32.  */
  33.  
  34. #include <strings.h>
  35. #include <stdio.h>
  36.  
  37. #include <sys/param.h>
  38. #include <sys/socket.h>
  39.  
  40. #include <netinet/in.h>
  41.  
  42. #include <netdb.h>
  43.  
  44. #include "main.h"
  45. #include "asn1.h"
  46. #include "snmp.h"
  47. #include "snmp_impl.h"
  48. #include "snmp_api.h"
  49. #include "snmp_client.h"
  50. #include "mib.h"
  51.  
  52. extern    int aflag;
  53. extern    int nflag;
  54. extern    char *plural();
  55. extern    char *malloc();
  56. extern    struct snmp_session *Session;
  57. extern    struct variable_list *getvarbyname();
  58.  
  59.  
  60. char    *inetname();
  61.  
  62. struct stat_table {
  63.     int        entry;  /* entry number in table */
  64.     /* format string to printf(description, value, plural(value)); */
  65.     /* warning: the %d must be before the %s */
  66.     char    description[80];
  67. };
  68.  
  69. static oid oid_ipstats[] = {1, 3, 6, 1, 2, 1, 4, 0, 0};
  70. struct stat_table ip_stattab[] = {
  71.     {3, "%d total datagram%s received"},
  72.     {4, "%d datagram%s with header errors"},
  73.     {5, "%d datagram%s with an invalid destination address"},
  74.     {6, "%d datagram%s forwarded"},
  75.     {7, "%d datagram%s with unknown protocol"},
  76.     {8, "%d datagram%s discarded"},
  77.     {9, "%d datagram%s delivered"},
  78.     {10, "%d output datagram request%s"},
  79.     {11, "%d output datagram%s discarded"},
  80.     {12, "%d datagram%s with no route"},
  81.     {14, "%d fragment%s received"},
  82.     {15, "%d datagram%s reassembled"},
  83.     {16, "%d reassembly failure%s"},
  84.     {17, "%d datagram%s fragmented"},
  85.     {18, "%d fragmentation failure%s"},
  86.     {19, "%d fragment%s created"}
  87. };
  88.  
  89. static oid oid_udpstats[] = {1, 3, 6, 1, 2, 1, 7, 0, 0};
  90. struct stat_table udp_stattab[] = {
  91.     {1, "%d total datagram%s received"},
  92.     {2, "%d datagram%s to invalid port"},
  93.     {3, "%d datagram%s dropped due to errors"},
  94.     {4, "%d output datagram request%s"}
  95. };
  96.  
  97. static oid oid_tcpstats[] = {1, 3, 6, 1, 2, 1, 6, 0, 0};
  98. struct stat_table tcp_stattab[] = {
  99.     {5, "%d active open%s"},
  100.     {6, "%d passive open%s"},
  101.     {7, "%d failed attempt%s"},
  102.     {8, "%d reset%s of established connections"},
  103.     {9, "%d current established connection%s"},
  104.     {10, "%d segment%s received"},
  105.     {11, "%d segment%s sent"},
  106.     {12, "%d segment%s retransmitted"}
  107. };
  108.  
  109. static oid oid_icmpstats[] = {1, 3, 6, 1, 2, 1, 5, 0, 0};
  110. struct stat_table icmp_stattab[] = {
  111.     {1, "%d total message%s received"},
  112.     {2, "%d message%s dropped due to errors"},
  113.     {14, "%d ouput message request%s"},
  114.     {15, "%d output message%s discarded"}
  115. };
  116.  
  117. struct stat_table icmp_inhistogram[] = {
  118.     {3, "Destination unreachable: %d"},
  119.     {4, "Time Exceeded: %d"},
  120.     {5, "Parameter Problem: %d"},
  121.     {6, "Source Quench: %d"},
  122.     {7, "Redirect: %d"},
  123.     {8, "Echo Request: %d"},
  124.     {9, "Echo Reply: %d"},
  125.     {10, "Timestamp Request: %d"},
  126.     {11, "Timestamp Reply: %d"},
  127.     {12, "Address Mask Request: %d"},
  128.     {13, "Addrss Mask Reply:%d"},
  129. };
  130.  
  131. struct stat_table icmp_outhistogram[] = {
  132.     {16, "Destination unreachable: %d"},
  133.     {17, "Time Exceeded: %d"},
  134.     {18, "Parameter Problem: %d"},
  135.     {19, "Source Quench: %d"},
  136.     {20, "Redirect: %d"},
  137.     {21, "Echo Request: %d"},
  138.     {22, "Echo Reply: %d"},
  139.     {23, "Timestamp Request: %d"},
  140.     {24, "Timestamp Reply: %d"},
  141.     {25, "Address Mask Request: %d"},
  142.     {26, "Addrss Mask Reply:%d"},
  143. };
  144.  
  145. struct tcpconn_entry {
  146.     oid        instance[10];
  147.     struct in_addr  localAddress;
  148.     int        locAddrSet;
  149.     u_short localPort;
  150.     int        locPortSet;
  151.     struct in_addr  remoteAddress;
  152.     int        remAddrSet;
  153.     u_short remotePort;
  154.     int        remPortSet;
  155.     int        state;
  156.     int        stateSet;
  157.     struct tcpconn_entry *next;
  158. };
  159.  
  160. #define TCPCONN_STATE    1
  161. #define TCPCONN_LOCADDR    2
  162. #define TCPCONN_LOCPORT    3
  163. #define TCPCONN_REMADDR    4
  164. #define TCPCONN_REMPORT    5
  165.  
  166.  
  167.  
  168. static oid oid_tcpconntable[] = {1, 3, 6, 1, 2, 1, 6, 13, 1};
  169. #define ENTRY 9
  170.  
  171. char *tcpstates[] = {
  172.     "",            "CLOSED",        "LISTEN",   "SYNSENT",
  173.     "SYNRECEIVED",  "ESTABLISHED",  "FINWAIT1", "FINWAIT2",
  174.     "CLOSEWAIT",    "LASTACK",        "CLOSING",    "TIMEWAIT"
  175. };
  176. #define TCP_NSTATES 11
  177.  
  178. /*
  179.  * Print a summary of connections related to an Internet
  180.  * protocol (currently only TCP).  For TCP, also give state of connection.
  181.  */
  182. protopr(){
  183.     struct tcpconn_entry *tcpconn = NULL, *tp, *newp;
  184.     struct snmp_pdu *request, *response;
  185.     struct variable_list *vp;
  186.     oid *instance;
  187.     int first, status;
  188.  
  189.     request = snmp_pdu_create(GETNEXT_REQ_MSG);
  190.  
  191.     snmp_add_null_var(request, oid_tcpconntable, sizeof(oid_tcpconntable)/sizeof(oid));
  192.  
  193.     while(1){
  194.     status = snmp_synch_response(Session, request, &response);
  195.     if (status != STAT_SUCCESS || response->errstat != SNMP_ERR_NOERROR){
  196.         fprintf(stderr, "SNMP request failed\n");
  197.         break;
  198.     }
  199.     vp = response->variables;
  200.     if (vp->name_length != 20 ||
  201.         bcmp((char *)vp->name, (char *)oid_tcpconntable, sizeof(oid_tcpconntable))){
  202.         break;
  203.     }
  204.     
  205.     request = snmp_pdu_create(GETNEXT_REQ_MSG);
  206.     snmp_add_null_var(request, vp->name, vp->name_length);
  207.  
  208.     instance = vp->name + 10;
  209.     for(tp = tcpconn; tp != NULL; tp = tp->next){
  210.         if (!bcmp((char *)instance, (char *)tp->instance,
  211.         sizeof(tp->instance)))
  212.             break;
  213.     }
  214.     if (tp == NULL){
  215.         newp = (struct tcpconn_entry *)malloc(sizeof(struct tcpconn_entry));
  216.         if (tcpconn == NULL){
  217.         tcpconn = newp;
  218.         } else {
  219.         for(tp = tcpconn; tp->next != NULL; tp = tp->next)
  220.             ;
  221.         tp->next = newp;
  222.         }
  223.         tp = newp;
  224.         bzero((char *)tp, sizeof(*tp));
  225.         tp->next = NULL;
  226.         bcopy((char *)instance, (char *)tp->instance, sizeof(tp->instance));
  227.     }
  228.  
  229.     if (vp->name[ENTRY] == TCPCONN_STATE){
  230.         tp->state = *vp->val.integer;
  231.         tp->stateSet = 1;
  232.  
  233.     }
  234.  
  235.     if (vp->name[ENTRY] == TCPCONN_LOCADDR){
  236.         bcopy((char *)vp->val.string, (char *)&tp->localAddress, sizeof(u_long));
  237.         tp->locAddrSet = 1;
  238.  
  239.     }
  240.  
  241.     if (vp->name[ENTRY] == TCPCONN_LOCPORT){
  242.         tp->localPort = *vp->val.integer;
  243.         tp->locPortSet = 1;
  244.  
  245.     }
  246.  
  247.     if (vp->name[ENTRY] == TCPCONN_REMADDR){
  248.         bcopy((char *)vp->val.string, (char *)&tp->remoteAddress, sizeof(u_long));
  249.         tp->remAddrSet = 1;
  250.  
  251.     }
  252.  
  253.     if (vp->name[ENTRY] == TCPCONN_REMPORT){
  254.         tp->remotePort = *vp->val.integer;
  255.         tp->remPortSet = 1;
  256.  
  257.     }
  258.  
  259.     }
  260.  
  261.     for(first = 1, tp = tcpconn; tp != NULL; tp = tp->next){
  262.     if (!(tp->stateSet && tp->locAddrSet
  263.         && tp->locPortSet && tp->remAddrSet && tp->remPortSet)){
  264.         printf("incomplete entry\n");
  265.         continue;
  266.     }
  267.     if (!aflag && tp->state == MIB_TCPCONNSTATE_LISTEN)
  268.             continue;
  269.     if (first){
  270.         printf("Active Internet Connections");
  271.         if (aflag)
  272.         printf(" (including servers)");
  273.         putchar('\n');
  274.         printf("%-5.5s %-6.6s %-6.6s  %-22.22s %-22.22s %s\n",
  275.             "Proto", "Recv-Q", "Send-Q",
  276.             "Local Address", "Foreign Address", "(state)");
  277.         first = 0;
  278.     }
  279.     printf("%-5.5s %6d %6d ", "tcp", 0, 0);
  280.     inetprint(&tp->localAddress, tp->localPort, "tcp");
  281.     inetprint(&tp->remoteAddress, tp->remotePort, "tcp");
  282.     if (tp->state < 1 || tp->state > TCP_NSTATES)
  283.         printf(" %d", tp->state);
  284.     else
  285.         printf(" %s", tcpstates[tp->state]);
  286.     putchar('\n');
  287.     }
  288.  
  289. }
  290.  
  291.  
  292. /*
  293.  * Dump UDP statistics structure.
  294.  */
  295. udp_stats()
  296. {
  297.     oid varname[MAX_NAME_LEN], *udpentry;
  298.     int varname_len;
  299.     struct variable_list *var;
  300.     int count;
  301.     struct stat_table *sp = udp_stattab;
  302.  
  303.     bcopy((char *)oid_udpstats, (char *)varname, sizeof(oid_udpstats));
  304.     varname_len = sizeof(oid_udpstats) / sizeof(oid);
  305.     udpentry = varname + 7;
  306.     printf("udp:\n");
  307.     count = sizeof(udp_stattab) / sizeof (struct stat_table);
  308.     while (count--){
  309.     *udpentry = sp->entry;
  310.     var = getvarbyname(Session, varname, varname_len);
  311.     if (var){
  312.         putchar('\t');
  313.         printf(sp->description, *var->val.integer, plural((int)*var->val.integer));
  314.         putchar('\n');
  315.     }
  316.     sp++;
  317.     }
  318.  
  319. }
  320.  
  321. /*
  322.  * Dump TCP statistics structure.
  323.  */
  324. tcp_stats()
  325. {
  326.     oid varname[MAX_NAME_LEN], *tcpentry;
  327.     int varname_len;
  328.     struct variable_list *var;
  329.     int count;
  330.     struct stat_table *sp = tcp_stattab;
  331.  
  332.     bcopy((char *)oid_tcpstats, (char *)varname, sizeof(oid_tcpstats));
  333.     varname_len = sizeof(oid_tcpstats) / sizeof(oid);
  334.     tcpentry = varname + 7;
  335.     printf("tcp:\n");
  336.     count = sizeof(tcp_stattab) / sizeof (struct stat_table);
  337.     while (count--){
  338.     *tcpentry = sp->entry;
  339.     var = getvarbyname(Session, varname, varname_len);
  340.     if (var){
  341.         putchar('\t');
  342.         printf(sp->description, *var->val.integer, plural((int)*var->val.integer));
  343.         putchar('\n');
  344.     }
  345.     sp++;
  346.     }
  347.  
  348. }
  349.  
  350. /*
  351.  * Dump IP statistics structure.
  352.  */
  353. ip_stats()
  354. {
  355.     oid varname[MAX_NAME_LEN], *ipentry;
  356.     int varname_len;
  357.     struct variable_list *var;
  358.     int count;
  359.     struct stat_table *sp = ip_stattab;
  360.  
  361.     bcopy((char *)oid_ipstats, (char *)varname, sizeof(oid_ipstats));
  362.     varname_len = sizeof(oid_ipstats) / sizeof(oid);
  363.     ipentry = varname + 7;
  364.     printf("ip:\n");
  365.     count = sizeof(ip_stattab) / sizeof (struct stat_table);
  366.     while (count--){
  367.     *ipentry = sp->entry;
  368.     var = getvarbyname(Session, varname, varname_len);
  369.     if (var){
  370.         putchar('\t');
  371.         printf(sp->description, *var->val.integer, plural((int)*var->val.integer));
  372.         putchar('\n');
  373.     }
  374.     sp++;
  375.     }
  376.  
  377. }
  378.  
  379. /*
  380.  * Dump ICMP statistics.
  381.  */
  382. icmp_stats()
  383. {
  384.     oid varname[MAX_NAME_LEN], *icmpentry;
  385.     int varname_len;
  386.     struct variable_list *var;
  387.     int count, first;
  388.     struct stat_table *sp;
  389.  
  390.     bcopy((char *)oid_icmpstats, (char *)varname, sizeof(oid_icmpstats));
  391.     varname_len = sizeof(oid_icmpstats) / sizeof(oid);
  392.     icmpentry = varname + 7;
  393.     printf("icmp:\n");
  394.     sp = icmp_stattab;
  395.     count = sizeof(icmp_stattab) / sizeof (struct stat_table);
  396.     while (count--){
  397.     *icmpentry = sp->entry;
  398.     var = getvarbyname(Session, varname, varname_len);
  399.     if (var){
  400.         putchar('\t');
  401.         printf(sp->description, *var->val.integer, plural((int)*var->val.integer));
  402.         putchar('\n');
  403.     }
  404.     sp++;
  405.     }
  406.  
  407.     sp = icmp_outhistogram;
  408.     first = 1;
  409.     count = sizeof(icmp_outhistogram) / sizeof (struct stat_table);
  410.     while (count--){
  411.     *icmpentry = sp->entry;
  412.     var = getvarbyname(Session, varname, varname_len);
  413.     if (var && *var->val.integer != 0){
  414.         if (first){
  415.         printf("\tOutput Histogram:\n");
  416.         first = 0;
  417.         }
  418.         printf("\t\t");
  419.         printf(sp->description, *var->val.integer, plural((int)*var->val.integer));
  420.         putchar('\n');
  421.     }
  422.     sp++;
  423.     }
  424.  
  425.     sp = icmp_inhistogram;
  426.     first = 1;
  427.     count = sizeof(icmp_inhistogram) / sizeof (struct stat_table);
  428.     while (count--){
  429.     *icmpentry = sp->entry;
  430.     var = getvarbyname(Session, varname, varname_len);
  431.     if (var && *var->val.integer != 0){
  432.         if (first){
  433.         printf("\tInput Histogram:\n");
  434.         first = 0;
  435.         }
  436.         printf("\t\t");
  437.         printf(sp->description, *var->val.integer, plural((int)*var->val.integer));
  438.         putchar('\n');
  439.     }
  440.     sp++;
  441.     }
  442. }
  443.  
  444. /*
  445.  * Pretty print an Internet address (net address + port).
  446.  * If the nflag was specified, use numbers instead of names.
  447.  */
  448. inetprint(in, port, proto)
  449.     register struct in_addr *in;
  450.     u_short port; 
  451.     char *proto;
  452. {
  453.     struct servent *sp = 0;
  454.     char line[80], *cp, *index();
  455.     int width;
  456.  
  457.     sprintf(line, "%.*s.", 16, inetname(*in));
  458.     cp = index(line, '\0');
  459.     if (!nflag && port)
  460.         sp = getservbyport((int)port, proto);
  461.     if (sp || port == 0)
  462.         sprintf(cp, "%.8s", sp ? sp->s_name : "*");
  463.     else
  464.         sprintf(cp, "%d", ntohs((u_short)port));
  465.     width = 22;
  466.     printf(" %-*.*s", width, width, line);
  467. }
  468.  
  469. /*
  470.  * Construct an Internet address representation.
  471.  * If the nflag has been supplied, give 
  472.  * numeric value, otherwise try for symbolic name.
  473.  */
  474. char *
  475. inetname(in)
  476.     struct in_addr in;
  477. {
  478.     register char *cp;
  479.     static char line[50];
  480.     struct hostent *hp;
  481.     struct netent *np;
  482.     static char domain[MAXHOSTNAMELEN + 1];
  483.     static int first = 1;
  484.  
  485.     if (first && !nflag) {
  486.         first = 0;
  487.         if (gethostname(domain, MAXHOSTNAMELEN) == 0 &&
  488.             (cp = index(domain, '.')))
  489.             (void) strcpy(domain, cp + 1);
  490.         else
  491.             domain[0] = 0;
  492.     }
  493.     cp = 0;
  494.     if (!nflag && in.s_addr != INADDR_ANY) {
  495.         u_long net = inet_netof(in);
  496.         u_long lna = inet_lnaof(in);
  497.  
  498.         if (lna == INADDR_ANY) {
  499.             np = getnetbyaddr(net, AF_INET);
  500.             if (np)
  501.                 cp = np->n_name;
  502.         }
  503.         if (cp == 0) {
  504.             hp = gethostbyaddr((char *)&in, sizeof (in), AF_INET);
  505.             if (hp) {
  506.                 if ((cp = index(hp->h_name, '.')) &&
  507.                     !strcmp(cp + 1, domain))
  508.                     *cp = 0;
  509.                 cp = hp->h_name;
  510.             }
  511.         }
  512.     }
  513.     if (in.s_addr == INADDR_ANY)
  514.         strcpy(line, "*");
  515.     else if (cp)
  516.         strcpy(line, cp);
  517.     else {
  518.         in.s_addr = ntohl(in.s_addr);
  519. #define C(x)    ((x) & 0xff)
  520.         sprintf(line, "%u.%u.%u.%u", C(in.s_addr >> 24),
  521.             C(in.s_addr >> 16), C(in.s_addr >> 8), C(in.s_addr));
  522.     }
  523.     return (line);
  524. }
  525.